using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Attributes;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Attributes.DomainAttributes;
using Baci.Net.ToolKit.ArcGISProGeoprocessor.Models.Enums;
using System.Collections.Generic;
using System.ComponentModel;

namespace Baci.ArcGIS._DataManagementTools._Topology
{
    /// <summary>
    /// <para>Add Rule To Topology</para>
    /// <para>Adds a new rule to a topology.</para>
    /// <para>向拓扑添加新规则。</para>
    /// </summary>    
    [DisplayName("Add Rule To Topology")]
    public class AddRuleToTopology : AbstractGPProcess
    {
        /// <summary>
        /// 无参构造
        /// </summary>
        public AddRuleToTopology()
        {

        }

        /// <summary>
        /// 有参构造
        /// </summary>
        /// <param name="_in_topology">
        /// <para>Input Topology</para>
        /// <para>The topology to which the new rule will be added.</para>
        /// <para>将添加新规则的拓扑。</para>
        /// </param>
        /// <param name="_rule_type">
        /// <para>Rule Type</para>
        /// <para><xdoc>
        ///   <para>The topology rule to be added. For a complete list of the rules and what they do, see the topology rules and fixes for point, line, or polygon features.</para>
        ///   <bulletList>
        ///     <bullet_item>Must Not Have Gaps (Area)— This rule requires that there are no voids within a single polygon or between adjacent polygons. All polygons must form a continuous surface. An error will always exist on the perimeter of the surface. You can either ignore this error or mark it as an exception. Use this rule on data that must completely cover an area. For example, soil polygons cannot include gaps or form voids-they must cover an entire area.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap (Area)— Requires that the interior of polygons not overlap. The polygons can share edges or vertices. This rule is used when an area cannot belong to two or more polygons. It is useful for modeling administrative boundaries, such as ZIP Codes or voting districts, and mutually exclusive area classifications, such as land cover or landform type.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Feature Class Of (Area-Area)— Requires that a polygon in one feature class (or subtype) must share all of its area with polygons in another feature class (or subtype). An area in the first feature class that is not covered by polygons from the other feature class is an error. This rule is used when an area of one type, such as a state, should be completely covered by areas of another type, such as counties.</bullet_item><para/>
        ///     <bullet_item>Must Cover Each Other (Area-Area)— Requires that the polygons of one feature class (or subtype) must share all of their area with the polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in either feature class that is not shared with the other is an error. This rule is used when two systems of classification are used for the same geographic area, and any given point defined in one system must also be defined in the other. One such case occurs with nested hierarchical datasets, such as census blocks and block groups or small watersheds and large drainage basins. The rule can also be applied to nonhierarchically related polygon feature classes, such as soil type and slope class.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By (Area-Area)— Requires that polygons of one feature class (or subtype) must be contained within polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in the contained feature class must be covered by an area in the covering feature class. This rule is used when area features of a given type must be located within features of another type. This rule is useful when modeling areas that are subsets of a larger surrounding area, such as management units within forests or blocks within block groups.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap With (Area-Area)— Requires that the interior of polygons in one feature class (or subtype) must not overlap with the interior of polygons in another feature class (or subtype). Polygons of the two feature classes can share edges or vertices or be completely disjointed. This rule is used when an area cannot belong to two separate feature classes. It is useful for combining two mutually exclusive systems of area classification, such as zoning and water body type, where areas defined within the zoning class cannot also be defined in the water body class and vice versa.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Boundary Of (Line-Area)— Requires that lines be covered by the boundaries of area features. This is useful for modeling lines, such as lot lines, that must coincide with the edge of polygon features, such as lots.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Boundary Of (Point-Area)— Requires that points fall on the boundaries of area features. This is useful when the point features help support the boundary system, such as boundary markers, which must be found on the edges of certain areas.</bullet_item><para/>
        ///     <bullet_item>Must Be Properly Inside (Point-Area)— Requires that points fall within area features. This is useful when the point features are related to polygons, such as wells and well pads or address points and parcels.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap (Line)— Requires that lines not overlap with lines in the same feature class (or subtype). This rule is used where line segments should not be duplicated, for example, in a stream feature class. Lines can cross or intersect but cannot share segments.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect (Line)— Requires that line features from the same feature class (or subtype) not cross or overlap each other. Lines can share endpoints. This rule is used for contour lines that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as street segments and intersections.</bullet_item><para/>
        ///     <bullet_item>Must Not Have Dangles (Line)— Requires that a line feature must touch lines from the same feature class (or subtype) at both endpoints. An endpoint that is not connected to another line is called a dangle. This rule is used when line features must form closed loops, such as when they are defining the boundaries of polygon features. It may also be used in cases where lines typically connect to other lines, as with streets. In this case, exceptions can be used where the rule is occasionally violated, as with cul-de-sac or dead-end street segments.</bullet_item><para/>
        ///     <bullet_item>Must Not Have Pseudo-Nodes (Line)— Requires that a line connect to at least two other lines at each endpoint. Lines that connect to one other line (or to themselves) are said to have pseudo nodes. This rule is used where line features must form closed loops, such as when they define the boundaries of polygons or when line features logically must connect to two other line features at each end, as with segments in a stream network, with exceptions being marked for the originating ends of first-order streams.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Feature Class Of (Line-Line)— Requires that lines from one feature class (or subtype) must be covered by the lines in another feature class (or subtype). This is useful for modeling logically different but spatially coincident lines, such as routes and streets. A bus route feature class must not depart from the streets defined in the street feature class.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap With (Line-Line)— Requires that a line from one feature class (or subtype) not overlap with line features in another feature class (or subtype). This rule is used when line features cannot share the same space. For example, roads must not overlap with railroads or depression subtypes of contour lines cannot overlap with other contour lines.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By (Point-Line)— Requires that points in one feature class be covered by lines in another feature class. It does not constrain the covering portion of the line to be an endpoint. This rule is useful for points that fall along a set of lines, such as highway signs along highways.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Endpoint Of (Point-Line)— Requires that points in one feature class must be covered by the endpoints of lines in another feature class. This rule is similar to the line rule Endpoint Must Be Covered By except that, in cases where the rule is violated, it is the point feature that is marked as an error rather than the line. Boundary corner markers might be constrained to be covered by the endpoints of boundary lines.</bullet_item><para/>
        ///     <bullet_item>Boundary Must Be Covered By (Area-Line)— Requires that boundaries of polygon features must be covered by lines in another feature class. This rule is used when area features need to have line features that mark the boundaries of the areas. This is usually when the areas have one set of attributes and their boundaries have other attributes. For example, parcels might be stored in the geodatabase along with their boundaries. Each parcel might be defined by one or more line features that store information about their length or the date surveyed, and every parcel should exactly match its boundaries.</bullet_item><para/>
        ///     <bullet_item>Boundary Must Be Covered By Boundary Of (Area-Area)— Requires that boundaries of polygon features in one feature class (or subtype) be covered by boundaries of polygon features in another feature class (or subtype). This is useful when polygon features in one feature class, such as subdivisions, are composed of multiple polygons in another class, such as parcels, and the shared boundaries must be aligned.</bullet_item><para/>
        ///     <bullet_item>Must Not Self-Overlap (Line)— Requires that line features not overlap themselves. They can cross or touch themselves but must not have coincident segments. This rule is useful for features, such as streets, where segments might touch in a loop but where the same street should not follow the same course twice.</bullet_item><para/>
        ///     <bullet_item>Must Not Self-Intersect (Line)— Requires that line features not cross or overlap themselves. This rule is useful for lines, such as contour lines, that cannot cross themselves.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect Or Touch Interior (Line)— Requires that a line in one feature class (or subtype) must only touch other lines of the same feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines must only be connected at endpoints, such as in the case of lot lines, which must split (only connect to the endpoints of) back lot lines and cannot overlap each other.</bullet_item><para/>
        ///     <bullet_item>Endpoint Must Be Covered By (Line-Point)— Requires that the endpoints of line features must be covered by point features in another feature class. This is useful for modeling cases where a fitting must connect two pipes or a street intersection must be found at the junction of two streets.</bullet_item><para/>
        ///     <bullet_item>Contains Point (Area-Point)— Requires that a polygon in one feature class contain at least one point from another feature class. Points must be within the polygon, not on the boundary. This is useful when every polygon should have at least one associated point, such as when parcels must have an address point.</bullet_item><para/>
        ///     <bullet_item>Must Be Single Part (Line)— Requires that lines have only one part. This rule is useful where line features, such as highways, may not have multiple parts.</bullet_item><para/>
        ///     <bullet_item>Must Coincide With (Point-Point)— Requires that points in one feature class (or subtype) be coincident with points in another feature class (or subtype). This is useful for cases where points must be covered by other points, such as transformers must coincide with power poles in electric distribution networks and observation points must coincide with stations.</bullet_item><para/>
        ///     <bullet_item>Must Be Disjoint (Point)— Requires that points be separated spatially from other points in the same feature class (or subtype). Any points that overlap are errors. This is useful for ensuring that points are not coincident or duplicated within the same feature class, such as in layers of cities, parcel lot ID points, wells, or streetlamp poles.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect With (Line-Line)— Requires that line features from one feature class (or subtype) not cross or overlap lines from another feature class (or subtype). Lines can share endpoints. This rule is used when there are lines from two layers that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as streets and railroads.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect or Touch Interior With (Line-Line)— Requires that a line in one feature class (or subtype) must only touch other lines of another feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines from two layers must only be connected at endpoints.</bullet_item><para/>
        ///     <bullet_item>Must Be Inside (Line-Area)— Requires that a line is contained within the boundary of an area feature. This is useful for cases where lines may partially or totally coincide with area boundaries but cannot extend beyond polygons, such as state highways that must be inside state borders and rivers that must be within watersheds.</bullet_item><para/>
        ///     <bullet_item>Contains One Point (Area-Point)— Requires that each polygon contains one point feature and that each point feature falls within a single polygon. This is used when there must be a one-to-one correspondence between features of a polygon feature class and features of a point feature class, such as administrative boundaries and their capital cities. Each point must be properly inside exactly one polygon and each polygon must properly contain exactly one point. Points must be within the polygon, not on the boundary.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>要添加的拓扑规则。有关规则及其作用的完整列表，请参阅点、线或面要素的拓扑规则和修复。</para>
        ///   <bulletList>
        ///     <bullet_item>不得有间隙（面积）— 此规则要求单个多边形内或相邻多边形之间没有空隙。所有多边形必须形成一个连续的曲面。曲面的周边将始终存在误差。您可以忽略此错误，也可以将其标记为异常。对必须完全覆盖某个区域的数据使用此规则。例如，土壤多边形不能包含间隙或形成空隙，它们必须覆盖整个区域。</bullet_item><para/>
        ///     <bullet_item>不得重叠（面积）- 要求面的内部不重叠。多边形可以共享边或顶点。当一个区域不能属于两个或多个面时，将使用此规则。它可用于对行政边界（如邮政编码或投票区）和互斥区域分类（如土地覆被或地貌类型）进行建模。</bullet_item><para/>
        ///     <bullet_item>必须被要素类覆盖 （Area-Area） - 要求一个要素类（或子类型）中的面必须与另一个要素类（或子类型）中的面共享其所有区域。第一个要素类中未被其他要素类的面覆盖的区域为错误。当一种类型的区域（如州）应完全被另一种类型的区域（如县）覆盖时，使用此规则。</bullet_item><para/>
        ///     <bullet_item>必须相互覆盖（面积-面积）- 要求一个要素类（或子类型）的面必须与另一个要素类（或子类型）的面共享其所有区域。多边形可以共享边或顶点。在任一要素类中定义的未与其他要素类共享的任何区域都是错误。当同一地理区域使用两个分类系统时，使用此规则，并且在一个系统中定义的任何给定点也必须在另一个系统中定义。嵌套分层数据集（例如人口普查区块和区块组或小流域和大流域）就出现了一种情况。该规则还可以应用于非层次相关面要素类，例如土壤类型和坡度类。</bullet_item><para/>
        ///     <bullet_item>必须覆盖 （Area-Area） - 要求一个要素类（或子类型）的面必须包含在另一个要素类（或子类型）的面中。多边形可以共享边或顶点。在所包含要素类中定义的任何区域都必须被覆盖要素类中的区域所覆盖。当给定类型的区域要素必须位于其他类型的要素中时，将使用此规则。在对作为较大周围区域的子集的区域进行建模时，此规则非常有用，例如林中的管理单元或区块组中的块。</bullet_item><para/>
        ///     <bullet_item>不得与 （Area-Area） 重叠 - 要求一个要素类（或子类型）中的面内部不得与另一个要素类（或子类型）中的面内部重叠。两个要素类的面可以共享边或折点，也可以完全不相交。当一个区域不能属于两个单独的要素类时，将使用此规则。它可用于组合两个互斥的区域分类系统，例如分区和水体类型，其中在分区类中定义的区域不能在水体类中定义，反之亦然。</bullet_item><para/>
        ///     <bullet_item>必须被 （线-区域） 的边界覆盖 - 要求线被区域要素的边界覆盖。这对于必须与面要素（如地段）的边缘重合的线（如地段线）建模非常有用。</bullet_item><para/>
        ///     <bullet_item>必须被边界覆盖（点-区域）- 要求点位于区域要素的边界上。当点要素有助于支持边界系统（例如边界标记）时，这非常有用，边界标记必须位于某些区域的边缘上。</bullet_item><para/>
        ///     <bullet_item>必须正确位于内部（点-区域）- 要求点位于区域要素内。当点要素与面（例如井和井场或地址点和宗地）相关时，此功能非常有用。</bullet_item><para/>
        ///     <bullet_item>不得重叠（线）- 要求线不得与同一要素类（或子类型）中的线重叠。此规则用于不应复制线段的情况，例如，在流要素类中。线可以交叉或相交，但不能共享线段。</bullet_item><para/>
        ///     <bullet_item>不得相交（线）- 要求来自同一要素类（或子类型）的线要素不得相互交叉或重叠。线路可以共享端点。此规则用于不应相互交叉的等值线，或者线的交点应仅出现在端点（如街段和交叉点）的情况。</bullet_item><para/>
        ///     <bullet_item>不得悬垂（线）- 要求线要素必须在两个端点处触及来自同一要素类（或子类型）的线。未连接到另一条线的端点称为悬垂。当线要素必须形成闭环时（例如，当它们定义面要素的边界时），将使用此规则。它也可以用于线路通常连接到其他线路的情况，例如街道。在这种情况下，在偶尔违反规则的情况下可以使用例外，例如死胡同或死胡同的路段。</bullet_item><para/>
        ///     <bullet_item>不得有伪节点（线路）— 要求一条线路连接到每个端点处的至少两条其他线路。连接到另一条线（或连接到自己）的线被称为具有伪节点。此规则适用于线要素必须形成闭环的情况，例如，当它们定义面的边界时，或者当线要素在逻辑上必须连接到两端的另外两个线要素时，就像流网络中的线段一样，但一阶流的起始端会标记例外情况。</bullet_item><para/>
        ///     <bullet_item>必须被要素类覆盖 （线-线）- 要求一个要素类（或子类型）中的线必须被另一个要素类（或子类型）中的线覆盖。这对于对逻辑上不同但空间上重合的线（例如路线和街道）进行建模非常有用。公交路径要素类不得偏离街道要素类中定义的街道。</bullet_item><para/>
        ///     <bullet_item>不得与 （Line-Line） 重叠 - 要求一个要素类（或子类型）中的线不得与另一个要素类（或子类型）中的线要素重叠。当线要素不能共享同一空间时，将使用此规则。例如，道路不得与铁路重叠，或者等高线的凹陷子类型不能与其他等高线重叠。</bullet_item><para/>
        ///     <bullet_item>必须被（点-线）覆盖 - 要求一个要素类中的点被另一个要素类中的线覆盖。它不会将线的覆盖部分限制为端点。此规则对于沿一组线落下的点（例如高速公路沿线的高速公路标志）非常有用。</bullet_item><para/>
        ///     <bullet_item>必须被 （点-线） 的端点覆盖 - 要求一个要素类中的点必须被另一个要素类中的线的端点覆盖。此规则类似于线规则“端点必须被覆盖”，不同之处在于，在违反规则的情况下，标记为错误的是点要素，而不是线。边界角标记可能被限制为边界线的端点所覆盖。</bullet_item><para/>
        ///     <bullet_item>边界必须由（面积线）覆盖 - 要求面要素的边界必须由其他要素类中的线覆盖。当区域要素需要具有标记区域边界的线要素时，将使用此规则。这通常是当区域具有一组属性而其边界具有其他属性时。例如，宗地可能与其边界一起存储在地理数据库中。每个宗地可以由一个或多个线要素定义，这些线要素存储有关其长度或测量日期的信息，并且每个宗地都应完全匹配其边界。</bullet_item><para/>
        ///     <bullet_item>边界必须由边界覆盖 （Area-Area）- 要求一个要素类（或子类型）中的面要素的边界被另一个要素类（或子类型）中的面要素边界覆盖。当一个要素类（例如细分）中的面要素由另一个类（例如宗地）中的多个面组成，并且必须对齐共享边界时，这将非常有用。</bullet_item><para/>
        ///     <bullet_item>不得自重叠（线）- 要求线要素本身不重叠。它们可以交叉或接触自己，但不能有重合的片段。此规则对于要素（例如街道）非常有用，在这些要素中，线段可能会在环路中接触，但同一条街道不应两次遵循相同的路线。</bullet_item><para/>
        ///     <bullet_item>不得自相交（线）- 要求线要素不能相互交叉或重叠。此规则对于不能自相交的线（如等高线）非常有用。</bullet_item><para/>
        ///     <bullet_item>不得与内部（线）相交或接触 - 要求一个要素类（或子类型）中的线只能在端点处接触同一要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当线只能在端点处连接时，此规则很有用，例如在批次线的情况下，批次线必须拆分（仅连接到）后批线的端点，并且不能相互重叠。</bullet_item><para/>
        ///     <bullet_item>端点必须被 （线点）覆盖 - 要求线要素的端点必须被其他要素类中的点要素覆盖。这对于以下情况非常有用：管接头必须连接两条管道，或者必须在两条街道的交汇处找到街道交叉口。</bullet_item><para/>
        ///     <bullet_item>包含点 （Area-Point） - 要求一个要素类中的面至少包含另一个要素类中的一个点。点必须位于面内，而不是边界上。当每个面都应至少有一个关联点时，例如宗地必须具有地址点时，这很有用。</bullet_item><para/>
        ///     <bullet_item>必须是单个零件（线）- 要求线只有一个零件。当线要素（例如高速公路）可能没有多个部分时，此规则非常有用。</bullet_item><para/>
        ///     <bullet_item>必须与 （Point-Point） 重合 - 要求一个要素类（或子类型）中的点与另一个要素类（或子类型）中的点重合。这对于点必须被其他点覆盖的情况很有用，例如变压器必须与配电网中的电线杆重合，观测点必须与站点重合。</bullet_item><para/>
        ///     <bullet_item>必须不相交（点）- 要求点在空间上与同一要素类（或子类型）中的其他点分开。任何重叠的点都是错误。这对于确保点在同一要素类中不重合或重复非常有用，例如在城市图层、宗地批 ID 点、井或路灯杆中。</bullet_item><para/>
        ///     <bullet_item>不得与 （Line-Line） 相交 - 要求一个要素类（或子类型）的线要素不得与另一个要素类（或子类型）的线相交或重叠。线路可以共享端点。当两个图层中的线不应相互交叉时，或者线的交点应仅发生在端点（例如街道和铁路）处时，将使用此规则。</bullet_item><para/>
        ///     <bullet_item>不得与内部相交或接触 （线-线） - 要求一个要素类（或子类型）中的线只能在端点处接触另一个要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当两个图层的线路只能在端点处连接时，此规则非常有用。</bullet_item><para/>
        ///     <bullet_item>必须位于内部（线-区域）- 要求线包含在区域要素的边界内。这对于线可能部分或完全重合区域边界但不能延伸到多边形之外的情况非常有用，例如必须在州边界内的州高速公路和必须在流域内的河流。</bullet_item><para/>
        ///     <bullet_item>包含一个点 （Area-Point） - 要求每个面包含一个点要素，并且每个点要素都位于单个面内。当面要素类的要素与点要素类的要素（例如行政边界及其首府城市）之间必须存在一对一对应关系时，会使用此选项。每个点必须正好位于一个多边形内，并且每个多边形必须正确地包含一个点。点必须位于面内，而不是边界上。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// </param>
        /// <param name="_in_featureclass">
        /// <para>Input Feature class</para>
        /// <para>The input or origin feature class.</para>
        /// <para>输入要素类或原点要素类。</para>
        /// </param>
        public AddRuleToTopology(object _in_topology, _rule_type_value _rule_type, object _in_featureclass)
        {
            this._in_topology = _in_topology;
            this._rule_type = _rule_type;
            this._in_featureclass = _in_featureclass;
        }
        public override string ToolboxName => "Data Management Tools";

        public override string ToolName => "Add Rule To Topology";

        public override string CallName => "management.AddRuleToTopology";

        public override List<string> AcceptEnvironments => ["workspace"];

        public override object[] ParameterInfo => [_in_topology, _rule_type.GetGPValue(), _in_featureclass, _subtype, _in_featureclass2, _subtype2, _out_topology];

        /// <summary>
        /// <para>Input Topology</para>
        /// <para>The topology to which the new rule will be added.</para>
        /// <para>将添加新规则的拓扑。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Topology")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public object _in_topology { get; set; }


        /// <summary>
        /// <para>Rule Type</para>
        /// <para><xdoc>
        ///   <para>The topology rule to be added. For a complete list of the rules and what they do, see the topology rules and fixes for point, line, or polygon features.</para>
        ///   <bulletList>
        ///     <bullet_item>Must Not Have Gaps (Area)— This rule requires that there are no voids within a single polygon or between adjacent polygons. All polygons must form a continuous surface. An error will always exist on the perimeter of the surface. You can either ignore this error or mark it as an exception. Use this rule on data that must completely cover an area. For example, soil polygons cannot include gaps or form voids-they must cover an entire area.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap (Area)— Requires that the interior of polygons not overlap. The polygons can share edges or vertices. This rule is used when an area cannot belong to two or more polygons. It is useful for modeling administrative boundaries, such as ZIP Codes or voting districts, and mutually exclusive area classifications, such as land cover or landform type.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Feature Class Of (Area-Area)— Requires that a polygon in one feature class (or subtype) must share all of its area with polygons in another feature class (or subtype). An area in the first feature class that is not covered by polygons from the other feature class is an error. This rule is used when an area of one type, such as a state, should be completely covered by areas of another type, such as counties.</bullet_item><para/>
        ///     <bullet_item>Must Cover Each Other (Area-Area)— Requires that the polygons of one feature class (or subtype) must share all of their area with the polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in either feature class that is not shared with the other is an error. This rule is used when two systems of classification are used for the same geographic area, and any given point defined in one system must also be defined in the other. One such case occurs with nested hierarchical datasets, such as census blocks and block groups or small watersheds and large drainage basins. The rule can also be applied to nonhierarchically related polygon feature classes, such as soil type and slope class.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By (Area-Area)— Requires that polygons of one feature class (or subtype) must be contained within polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in the contained feature class must be covered by an area in the covering feature class. This rule is used when area features of a given type must be located within features of another type. This rule is useful when modeling areas that are subsets of a larger surrounding area, such as management units within forests or blocks within block groups.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap With (Area-Area)— Requires that the interior of polygons in one feature class (or subtype) must not overlap with the interior of polygons in another feature class (or subtype). Polygons of the two feature classes can share edges or vertices or be completely disjointed. This rule is used when an area cannot belong to two separate feature classes. It is useful for combining two mutually exclusive systems of area classification, such as zoning and water body type, where areas defined within the zoning class cannot also be defined in the water body class and vice versa.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Boundary Of (Line-Area)— Requires that lines be covered by the boundaries of area features. This is useful for modeling lines, such as lot lines, that must coincide with the edge of polygon features, such as lots.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Boundary Of (Point-Area)— Requires that points fall on the boundaries of area features. This is useful when the point features help support the boundary system, such as boundary markers, which must be found on the edges of certain areas.</bullet_item><para/>
        ///     <bullet_item>Must Be Properly Inside (Point-Area)— Requires that points fall within area features. This is useful when the point features are related to polygons, such as wells and well pads or address points and parcels.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap (Line)— Requires that lines not overlap with lines in the same feature class (or subtype). This rule is used where line segments should not be duplicated, for example, in a stream feature class. Lines can cross or intersect but cannot share segments.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect (Line)— Requires that line features from the same feature class (or subtype) not cross or overlap each other. Lines can share endpoints. This rule is used for contour lines that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as street segments and intersections.</bullet_item><para/>
        ///     <bullet_item>Must Not Have Dangles (Line)— Requires that a line feature must touch lines from the same feature class (or subtype) at both endpoints. An endpoint that is not connected to another line is called a dangle. This rule is used when line features must form closed loops, such as when they are defining the boundaries of polygon features. It may also be used in cases where lines typically connect to other lines, as with streets. In this case, exceptions can be used where the rule is occasionally violated, as with cul-de-sac or dead-end street segments.</bullet_item><para/>
        ///     <bullet_item>Must Not Have Pseudo-Nodes (Line)— Requires that a line connect to at least two other lines at each endpoint. Lines that connect to one other line (or to themselves) are said to have pseudo nodes. This rule is used where line features must form closed loops, such as when they define the boundaries of polygons or when line features logically must connect to two other line features at each end, as with segments in a stream network, with exceptions being marked for the originating ends of first-order streams.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Feature Class Of (Line-Line)— Requires that lines from one feature class (or subtype) must be covered by the lines in another feature class (or subtype). This is useful for modeling logically different but spatially coincident lines, such as routes and streets. A bus route feature class must not depart from the streets defined in the street feature class.</bullet_item><para/>
        ///     <bullet_item>Must Not Overlap With (Line-Line)— Requires that a line from one feature class (or subtype) not overlap with line features in another feature class (or subtype). This rule is used when line features cannot share the same space. For example, roads must not overlap with railroads or depression subtypes of contour lines cannot overlap with other contour lines.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By (Point-Line)— Requires that points in one feature class be covered by lines in another feature class. It does not constrain the covering portion of the line to be an endpoint. This rule is useful for points that fall along a set of lines, such as highway signs along highways.</bullet_item><para/>
        ///     <bullet_item>Must Be Covered By Endpoint Of (Point-Line)— Requires that points in one feature class must be covered by the endpoints of lines in another feature class. This rule is similar to the line rule Endpoint Must Be Covered By except that, in cases where the rule is violated, it is the point feature that is marked as an error rather than the line. Boundary corner markers might be constrained to be covered by the endpoints of boundary lines.</bullet_item><para/>
        ///     <bullet_item>Boundary Must Be Covered By (Area-Line)— Requires that boundaries of polygon features must be covered by lines in another feature class. This rule is used when area features need to have line features that mark the boundaries of the areas. This is usually when the areas have one set of attributes and their boundaries have other attributes. For example, parcels might be stored in the geodatabase along with their boundaries. Each parcel might be defined by one or more line features that store information about their length or the date surveyed, and every parcel should exactly match its boundaries.</bullet_item><para/>
        ///     <bullet_item>Boundary Must Be Covered By Boundary Of (Area-Area)— Requires that boundaries of polygon features in one feature class (or subtype) be covered by boundaries of polygon features in another feature class (or subtype). This is useful when polygon features in one feature class, such as subdivisions, are composed of multiple polygons in another class, such as parcels, and the shared boundaries must be aligned.</bullet_item><para/>
        ///     <bullet_item>Must Not Self-Overlap (Line)— Requires that line features not overlap themselves. They can cross or touch themselves but must not have coincident segments. This rule is useful for features, such as streets, where segments might touch in a loop but where the same street should not follow the same course twice.</bullet_item><para/>
        ///     <bullet_item>Must Not Self-Intersect (Line)— Requires that line features not cross or overlap themselves. This rule is useful for lines, such as contour lines, that cannot cross themselves.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect Or Touch Interior (Line)— Requires that a line in one feature class (or subtype) must only touch other lines of the same feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines must only be connected at endpoints, such as in the case of lot lines, which must split (only connect to the endpoints of) back lot lines and cannot overlap each other.</bullet_item><para/>
        ///     <bullet_item>Endpoint Must Be Covered By (Line-Point)— Requires that the endpoints of line features must be covered by point features in another feature class. This is useful for modeling cases where a fitting must connect two pipes or a street intersection must be found at the junction of two streets.</bullet_item><para/>
        ///     <bullet_item>Contains Point (Area-Point)— Requires that a polygon in one feature class contain at least one point from another feature class. Points must be within the polygon, not on the boundary. This is useful when every polygon should have at least one associated point, such as when parcels must have an address point.</bullet_item><para/>
        ///     <bullet_item>Must Be Single Part (Line)— Requires that lines have only one part. This rule is useful where line features, such as highways, may not have multiple parts.</bullet_item><para/>
        ///     <bullet_item>Must Coincide With (Point-Point)— Requires that points in one feature class (or subtype) be coincident with points in another feature class (or subtype). This is useful for cases where points must be covered by other points, such as transformers must coincide with power poles in electric distribution networks and observation points must coincide with stations.</bullet_item><para/>
        ///     <bullet_item>Must Be Disjoint (Point)— Requires that points be separated spatially from other points in the same feature class (or subtype). Any points that overlap are errors. This is useful for ensuring that points are not coincident or duplicated within the same feature class, such as in layers of cities, parcel lot ID points, wells, or streetlamp poles.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect With (Line-Line)— Requires that line features from one feature class (or subtype) not cross or overlap lines from another feature class (or subtype). Lines can share endpoints. This rule is used when there are lines from two layers that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as streets and railroads.</bullet_item><para/>
        ///     <bullet_item>Must Not Intersect or Touch Interior With (Line-Line)— Requires that a line in one feature class (or subtype) must only touch other lines of another feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines from two layers must only be connected at endpoints.</bullet_item><para/>
        ///     <bullet_item>Must Be Inside (Line-Area)— Requires that a line is contained within the boundary of an area feature. This is useful for cases where lines may partially or totally coincide with area boundaries but cannot extend beyond polygons, such as state highways that must be inside state borders and rivers that must be within watersheds.</bullet_item><para/>
        ///     <bullet_item>Contains One Point (Area-Point)— Requires that each polygon contains one point feature and that each point feature falls within a single polygon. This is used when there must be a one-to-one correspondence between features of a polygon feature class and features of a point feature class, such as administrative boundaries and their capital cities. Each point must be properly inside exactly one polygon and each polygon must properly contain exactly one point. Points must be within the polygon, not on the boundary.</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para><xdoc>
        ///   <para>要添加的拓扑规则。有关规则及其作用的完整列表，请参阅点、线或面要素的拓扑规则和修复。</para>
        ///   <bulletList>
        ///     <bullet_item>不得有间隙（面积）— 此规则要求单个多边形内或相邻多边形之间没有空隙。所有多边形必须形成一个连续的曲面。曲面的周边将始终存在误差。您可以忽略此错误，也可以将其标记为异常。对必须完全覆盖某个区域的数据使用此规则。例如，土壤多边形不能包含间隙或形成空隙，它们必须覆盖整个区域。</bullet_item><para/>
        ///     <bullet_item>不得重叠（面积）- 要求面的内部不重叠。多边形可以共享边或顶点。当一个区域不能属于两个或多个面时，将使用此规则。它可用于对行政边界（如邮政编码或投票区）和互斥区域分类（如土地覆被或地貌类型）进行建模。</bullet_item><para/>
        ///     <bullet_item>必须被要素类覆盖 （Area-Area） - 要求一个要素类（或子类型）中的面必须与另一个要素类（或子类型）中的面共享其所有区域。第一个要素类中未被其他要素类的面覆盖的区域为错误。当一种类型的区域（如州）应完全被另一种类型的区域（如县）覆盖时，使用此规则。</bullet_item><para/>
        ///     <bullet_item>必须相互覆盖（面积-面积）- 要求一个要素类（或子类型）的面必须与另一个要素类（或子类型）的面共享其所有区域。多边形可以共享边或顶点。在任一要素类中定义的未与其他要素类共享的任何区域都是错误。当同一地理区域使用两个分类系统时，使用此规则，并且在一个系统中定义的任何给定点也必须在另一个系统中定义。嵌套分层数据集（例如人口普查区块和区块组或小流域和大流域）就出现了一种情况。该规则还可以应用于非层次相关面要素类，例如土壤类型和坡度类。</bullet_item><para/>
        ///     <bullet_item>必须覆盖 （Area-Area） - 要求一个要素类（或子类型）的面必须包含在另一个要素类（或子类型）的面中。多边形可以共享边或顶点。在所包含要素类中定义的任何区域都必须被覆盖要素类中的区域所覆盖。当给定类型的区域要素必须位于其他类型的要素中时，将使用此规则。在对作为较大周围区域的子集的区域进行建模时，此规则非常有用，例如林中的管理单元或区块组中的块。</bullet_item><para/>
        ///     <bullet_item>不得与 （Area-Area） 重叠 - 要求一个要素类（或子类型）中的面内部不得与另一个要素类（或子类型）中的面内部重叠。两个要素类的面可以共享边或折点，也可以完全不相交。当一个区域不能属于两个单独的要素类时，将使用此规则。它可用于组合两个互斥的区域分类系统，例如分区和水体类型，其中在分区类中定义的区域不能在水体类中定义，反之亦然。</bullet_item><para/>
        ///     <bullet_item>必须被 （线-区域） 的边界覆盖 - 要求线被区域要素的边界覆盖。这对于必须与面要素（如地段）的边缘重合的线（如地段线）建模非常有用。</bullet_item><para/>
        ///     <bullet_item>必须被边界覆盖（点-区域）- 要求点位于区域要素的边界上。当点要素有助于支持边界系统（例如边界标记）时，这非常有用，边界标记必须位于某些区域的边缘上。</bullet_item><para/>
        ///     <bullet_item>必须正确位于内部（点-区域）- 要求点位于区域要素内。当点要素与面（例如井和井场或地址点和宗地）相关时，此功能非常有用。</bullet_item><para/>
        ///     <bullet_item>不得重叠（线）- 要求线不得与同一要素类（或子类型）中的线重叠。此规则用于不应复制线段的情况，例如，在流要素类中。线可以交叉或相交，但不能共享线段。</bullet_item><para/>
        ///     <bullet_item>不得相交（线）- 要求来自同一要素类（或子类型）的线要素不得相互交叉或重叠。线路可以共享端点。此规则用于不应相互交叉的等值线，或者线的交点应仅出现在端点（如街段和交叉点）的情况。</bullet_item><para/>
        ///     <bullet_item>不得悬垂（线）- 要求线要素必须在两个端点处触及来自同一要素类（或子类型）的线。未连接到另一条线的端点称为悬垂。当线要素必须形成闭环时（例如，当它们定义面要素的边界时），将使用此规则。它也可以用于线路通常连接到其他线路的情况，例如街道。在这种情况下，在偶尔违反规则的情况下可以使用例外，例如死胡同或死胡同的路段。</bullet_item><para/>
        ///     <bullet_item>不得有伪节点（线路）— 要求一条线路连接到每个端点处的至少两条其他线路。连接到另一条线（或连接到自己）的线被称为具有伪节点。此规则适用于线要素必须形成闭环的情况，例如，当它们定义面的边界时，或者当线要素在逻辑上必须连接到两端的另外两个线要素时，就像流网络中的线段一样，但一阶流的起始端会标记例外情况。</bullet_item><para/>
        ///     <bullet_item>必须被要素类覆盖 （线-线）- 要求一个要素类（或子类型）中的线必须被另一个要素类（或子类型）中的线覆盖。这对于对逻辑上不同但空间上重合的线（例如路线和街道）进行建模非常有用。公交路径要素类不得偏离街道要素类中定义的街道。</bullet_item><para/>
        ///     <bullet_item>不得与 （Line-Line） 重叠 - 要求一个要素类（或子类型）中的线不得与另一个要素类（或子类型）中的线要素重叠。当线要素不能共享同一空间时，将使用此规则。例如，道路不得与铁路重叠，或者等高线的凹陷子类型不能与其他等高线重叠。</bullet_item><para/>
        ///     <bullet_item>必须被（点-线）覆盖 - 要求一个要素类中的点被另一个要素类中的线覆盖。它不会将线的覆盖部分限制为端点。此规则对于沿一组线落下的点（例如高速公路沿线的高速公路标志）非常有用。</bullet_item><para/>
        ///     <bullet_item>必须被 （点-线） 的端点覆盖 - 要求一个要素类中的点必须被另一个要素类中的线的端点覆盖。此规则类似于线规则“端点必须被覆盖”，不同之处在于，在违反规则的情况下，标记为错误的是点要素，而不是线。边界角标记可能被限制为边界线的端点所覆盖。</bullet_item><para/>
        ///     <bullet_item>边界必须由（面积线）覆盖 - 要求面要素的边界必须由其他要素类中的线覆盖。当区域要素需要具有标记区域边界的线要素时，将使用此规则。这通常是当区域具有一组属性而其边界具有其他属性时。例如，宗地可能与其边界一起存储在地理数据库中。每个宗地可以由一个或多个线要素定义，这些线要素存储有关其长度或测量日期的信息，并且每个宗地都应完全匹配其边界。</bullet_item><para/>
        ///     <bullet_item>边界必须由边界覆盖 （Area-Area）- 要求一个要素类（或子类型）中的面要素的边界被另一个要素类（或子类型）中的面要素边界覆盖。当一个要素类（例如细分）中的面要素由另一个类（例如宗地）中的多个面组成，并且必须对齐共享边界时，这将非常有用。</bullet_item><para/>
        ///     <bullet_item>不得自重叠（线）- 要求线要素本身不重叠。它们可以交叉或接触自己，但不能有重合的片段。此规则对于要素（例如街道）非常有用，在这些要素中，线段可能会在环路中接触，但同一条街道不应两次遵循相同的路线。</bullet_item><para/>
        ///     <bullet_item>不得自相交（线）- 要求线要素不能相互交叉或重叠。此规则对于不能自相交的线（如等高线）非常有用。</bullet_item><para/>
        ///     <bullet_item>不得与内部（线）相交或接触 - 要求一个要素类（或子类型）中的线只能在端点处接触同一要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当线只能在端点处连接时，此规则很有用，例如在批次线的情况下，批次线必须拆分（仅连接到）后批线的端点，并且不能相互重叠。</bullet_item><para/>
        ///     <bullet_item>端点必须被 （线点）覆盖 - 要求线要素的端点必须被其他要素类中的点要素覆盖。这对于以下情况非常有用：管接头必须连接两条管道，或者必须在两条街道的交汇处找到街道交叉口。</bullet_item><para/>
        ///     <bullet_item>包含点 （Area-Point） - 要求一个要素类中的面至少包含另一个要素类中的一个点。点必须位于面内，而不是边界上。当每个面都应至少有一个关联点时，例如宗地必须具有地址点时，这很有用。</bullet_item><para/>
        ///     <bullet_item>必须是单个零件（线）- 要求线只有一个零件。当线要素（例如高速公路）可能没有多个部分时，此规则非常有用。</bullet_item><para/>
        ///     <bullet_item>必须与 （Point-Point） 重合 - 要求一个要素类（或子类型）中的点与另一个要素类（或子类型）中的点重合。这对于点必须被其他点覆盖的情况很有用，例如变压器必须与配电网中的电线杆重合，观测点必须与站点重合。</bullet_item><para/>
        ///     <bullet_item>必须不相交（点）- 要求点在空间上与同一要素类（或子类型）中的其他点分开。任何重叠的点都是错误。这对于确保点在同一要素类中不重合或重复非常有用，例如在城市图层、宗地批 ID 点、井或路灯杆中。</bullet_item><para/>
        ///     <bullet_item>不得与 （Line-Line） 相交 - 要求一个要素类（或子类型）的线要素不得与另一个要素类（或子类型）的线相交或重叠。线路可以共享端点。当两个图层中的线不应相互交叉时，或者线的交点应仅发生在端点（例如街道和铁路）处时，将使用此规则。</bullet_item><para/>
        ///     <bullet_item>不得与内部相交或接触 （线-线） - 要求一个要素类（或子类型）中的线只能在端点处接触另一个要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当两个图层的线路只能在端点处连接时，此规则非常有用。</bullet_item><para/>
        ///     <bullet_item>必须位于内部（线-区域）- 要求线包含在区域要素的边界内。这对于线可能部分或完全重合区域边界但不能延伸到多边形之外的情况非常有用，例如必须在州边界内的州高速公路和必须在流域内的河流。</bullet_item><para/>
        ///     <bullet_item>包含一个点 （Area-Point） - 要求每个面包含一个点要素，并且每个点要素都位于单个面内。当面要素类的要素与点要素类的要素（例如行政边界及其首府城市）之间必须存在一对一对应关系时，会使用此选项。每个点必须正好位于一个多边形内，并且每个多边形必须正确地包含一个点。点必须位于面内，而不是边界上。</bullet_item><para/>
        ///   </bulletList>
        /// </xdoc></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Rule Type")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public _rule_type_value _rule_type { get; set; }

        public enum _rule_type_value
        {
            /// <summary>
            /// <para>Must Not Have Gaps (Area)</para>
            /// <para>Must Not Have Gaps (Area)— This rule requires that there are no voids within a single polygon or between adjacent polygons. All polygons must form a continuous surface. An error will always exist on the perimeter of the surface. You can either ignore this error or mark it as an exception. Use this rule on data that must completely cover an area. For example, soil polygons cannot include gaps or form voids-they must cover an entire area.</para>
            /// <para>不得有间隙（面积）— 此规则要求单个多边形内或相邻多边形之间没有空隙。所有多边形必须形成一个连续的曲面。曲面的周边将始终存在误差。您可以忽略此错误，也可以将其标记为异常。对必须完全覆盖某个区域的数据使用此规则。例如，土壤多边形不能包含间隙或形成空隙，它们必须覆盖整个区域。</para>
            /// </summary>
            [Description("Must Not Have Gaps (Area)")]
            [GPEnumValue("Must Not Have Gaps (Area)")]
            value0,

            /// <summary>
            /// <para>Must Not Overlap (Area)</para>
            /// <para>Must Not Overlap (Area)— Requires that the interior of polygons not overlap. The polygons can share edges or vertices. This rule is used when an area cannot belong to two or more polygons. It is useful for modeling administrative boundaries, such as ZIP Codes or voting districts, and mutually exclusive area classifications, such as land cover or landform type.</para>
            /// <para>不得重叠（面积）- 要求面的内部不重叠。多边形可以共享边或顶点。当一个区域不能属于两个或多个面时，将使用此规则。它可用于对行政边界（如邮政编码或投票区）和互斥区域分类（如土地覆被或地貌类型）进行建模。</para>
            /// </summary>
            [Description("Must Not Overlap (Area)")]
            [GPEnumValue("Must Not Overlap (Area)")]
            value1,

            /// <summary>
            /// <para>Must Be Covered By Feature Class Of (Area-Area)</para>
            /// <para>Must Be Covered By Feature Class Of (Area-Area)— Requires that a polygon in one feature class (or subtype) must share all of its area with polygons in another feature class (or subtype). An area in the first feature class that is not covered by polygons from the other feature class is an error. This rule is used when an area of one type, such as a state, should be completely covered by areas of another type, such as counties.</para>
            /// <para>必须被要素类覆盖 （Area-Area） - 要求一个要素类（或子类型）中的面必须与另一个要素类（或子类型）中的面共享其所有区域。第一个要素类中未被其他要素类的面覆盖的区域为错误。当一种类型的区域（如州）应完全被另一种类型的区域（如县）覆盖时，使用此规则。</para>
            /// </summary>
            [Description("Must Be Covered By Feature Class Of (Area-Area)")]
            [GPEnumValue("Must Be Covered By Feature Class Of (Area-Area)")]
            value2,

            /// <summary>
            /// <para>Must Cover Each Other (Area-Area)</para>
            /// <para>Must Cover Each Other (Area-Area)— Requires that the polygons of one feature class (or subtype) must share all of their area with the polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in either feature class that is not shared with the other is an error. This rule is used when two systems of classification are used for the same geographic area, and any given point defined in one system must also be defined in the other. One such case occurs with nested hierarchical datasets, such as census blocks and block groups or small watersheds and large drainage basins. The rule can also be applied to nonhierarchically related polygon feature classes, such as soil type and slope class.</para>
            /// <para>必须相互覆盖（面积-面积）- 要求一个要素类（或子类型）的面必须与另一个要素类（或子类型）的面共享其所有区域。多边形可以共享边或顶点。在任一要素类中定义的未与其他要素类共享的任何区域都是错误。当同一地理区域使用两个分类系统时，使用此规则，并且在一个系统中定义的任何给定点也必须在另一个系统中定义。嵌套分层数据集（例如人口普查区块和区块组或小流域和大流域）就出现了一种情况。该规则还可以应用于非层次相关面要素类，例如土壤类型和坡度类。</para>
            /// </summary>
            [Description("Must Cover Each Other (Area-Area)")]
            [GPEnumValue("Must Cover Each Other (Area-Area)")]
            value3,

            /// <summary>
            /// <para>Must Be Covered By (Area-Area)</para>
            /// <para>Must Be Covered By (Area-Area)— Requires that polygons of one feature class (or subtype) must be contained within polygons of another feature class (or subtype). Polygons may share edges or vertices. Any area defined in the contained feature class must be covered by an area in the covering feature class. This rule is used when area features of a given type must be located within features of another type. This rule is useful when modeling areas that are subsets of a larger surrounding area, such as management units within forests or blocks within block groups.</para>
            /// <para>必须覆盖 （Area-Area） - 要求一个要素类（或子类型）的面必须包含在另一个要素类（或子类型）的面中。多边形可以共享边或顶点。在所包含要素类中定义的任何区域都必须被覆盖要素类中的区域所覆盖。当给定类型的区域要素必须位于其他类型的要素中时，将使用此规则。在对作为较大周围区域的子集的区域进行建模时，此规则非常有用，例如林中的管理单元或区块组中的块。</para>
            /// </summary>
            [Description("Must Be Covered By (Area-Area)")]
            [GPEnumValue("Must Be Covered By (Area-Area)")]
            value4,

            /// <summary>
            /// <para>Must Not Overlap With (Area-Area)</para>
            /// <para>Must Not Overlap With (Area-Area)— Requires that the interior of polygons in one feature class (or subtype) must not overlap with the interior of polygons in another feature class (or subtype). Polygons of the two feature classes can share edges or vertices or be completely disjointed. This rule is used when an area cannot belong to two separate feature classes. It is useful for combining two mutually exclusive systems of area classification, such as zoning and water body type, where areas defined within the zoning class cannot also be defined in the water body class and vice versa.</para>
            /// <para>不得与 （Area-Area） 重叠 - 要求一个要素类（或子类型）中的面内部不得与另一个要素类（或子类型）中的面内部重叠。两个要素类的面可以共享边或折点，也可以完全不相交。当一个区域不能属于两个单独的要素类时，将使用此规则。它可用于组合两个互斥的区域分类系统，例如分区和水体类型，其中在分区类中定义的区域不能在水体类中定义，反之亦然。</para>
            /// </summary>
            [Description("Must Not Overlap With (Area-Area)")]
            [GPEnumValue("Must Not Overlap With (Area-Area)")]
            value5,

            /// <summary>
            /// <para>Must Be Covered By Boundary Of (Line-Area)</para>
            /// <para>Must Be Covered By Boundary Of (Line-Area)— Requires that lines be covered by the boundaries of area features. This is useful for modeling lines, such as lot lines, that must coincide with the edge of polygon features, such as lots.</para>
            /// <para>必须被 （线-区域） 的边界覆盖 - 要求线被区域要素的边界覆盖。这对于必须与面要素（如地段）的边缘重合的线（如地段线）建模非常有用。</para>
            /// </summary>
            [Description("Must Be Covered By Boundary Of (Line-Area)")]
            [GPEnumValue("Must Be Covered By Boundary Of (Line-Area)")]
            value6,

            /// <summary>
            /// <para>Must Be Covered By Boundary Of (Point-Area)</para>
            /// <para>Must Be Covered By Boundary Of (Point-Area)— Requires that points fall on the boundaries of area features. This is useful when the point features help support the boundary system, such as boundary markers, which must be found on the edges of certain areas.</para>
            /// <para>必须被边界覆盖（点-区域）- 要求点位于区域要素的边界上。当点要素有助于支持边界系统（例如边界标记）时，这非常有用，边界标记必须位于某些区域的边缘上。</para>
            /// </summary>
            [Description("Must Be Covered By Boundary Of (Point-Area)")]
            [GPEnumValue("Must Be Covered By Boundary Of (Point-Area)")]
            value7,

            /// <summary>
            /// <para>Must Be Properly Inside (Point-Area)</para>
            /// <para>Must Be Properly Inside (Point-Area)— Requires that points fall within area features. This is useful when the point features are related to polygons, such as wells and well pads or address points and parcels.</para>
            /// <para>必须正确位于内部（点-区域）- 要求点位于区域要素内。当点要素与面（例如井和井场或地址点和宗地）相关时，此功能非常有用。</para>
            /// </summary>
            [Description("Must Be Properly Inside (Point-Area)")]
            [GPEnumValue("Must Be Properly Inside (Point-Area)")]
            value8,

            /// <summary>
            /// <para>Must Not Overlap (Line)</para>
            /// <para>Must Not Overlap (Line)— Requires that lines not overlap with lines in the same feature class (or subtype). This rule is used where line segments should not be duplicated, for example, in a stream feature class. Lines can cross or intersect but cannot share segments.</para>
            /// <para>不得重叠（线）- 要求线不得与同一要素类（或子类型）中的线重叠。此规则用于不应复制线段的情况，例如，在流要素类中。线可以交叉或相交，但不能共享线段。</para>
            /// </summary>
            [Description("Must Not Overlap (Line)")]
            [GPEnumValue("Must Not Overlap (Line)")]
            value9,

            /// <summary>
            /// <para>Must Not Intersect (Line)</para>
            /// <para>Must Not Intersect (Line)— Requires that line features from the same feature class (or subtype) not cross or overlap each other. Lines can share endpoints. This rule is used for contour lines that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as street segments and intersections.</para>
            /// <para>不得相交（线）- 要求来自同一要素类（或子类型）的线要素不得相互交叉或重叠。线路可以共享端点。此规则用于不应相互交叉的等值线，或者线的交点应仅出现在端点（如街段和交叉点）的情况。</para>
            /// </summary>
            [Description("Must Not Intersect (Line)")]
            [GPEnumValue("Must Not Intersect (Line)")]
            value10,

            /// <summary>
            /// <para>Must Not Have Dangles (Line)</para>
            /// <para>Must Not Have Dangles (Line)— Requires that a line feature must touch lines from the same feature class (or subtype) at both endpoints. An endpoint that is not connected to another line is called a dangle. This rule is used when line features must form closed loops, such as when they are defining the boundaries of polygon features. It may also be used in cases where lines typically connect to other lines, as with streets. In this case, exceptions can be used where the rule is occasionally violated, as with cul-de-sac or dead-end street segments.</para>
            /// <para>不得悬垂（线）- 要求线要素必须在两个端点处触及来自同一要素类（或子类型）的线。未连接到另一条线的端点称为悬垂。当线要素必须形成闭环时（例如，当它们定义面要素的边界时），将使用此规则。它也可以用于线路通常连接到其他线路的情况，例如街道。在这种情况下，在偶尔违反规则的情况下可以使用例外，例如死胡同或死胡同的路段。</para>
            /// </summary>
            [Description("Must Not Have Dangles (Line)")]
            [GPEnumValue("Must Not Have Dangles (Line)")]
            value11,

            /// <summary>
            /// <para>Must Not Have Pseudo-Nodes (Line)</para>
            /// <para>Must Not Have Pseudo-Nodes (Line)— Requires that a line connect to at least two other lines at each endpoint. Lines that connect to one other line (or to themselves) are said to have pseudo nodes. This rule is used where line features must form closed loops, such as when they define the boundaries of polygons or when line features logically must connect to two other line features at each end, as with segments in a stream network, with exceptions being marked for the originating ends of first-order streams.</para>
            /// <para>不得有伪节点（线路）— 要求一条线路连接到每个端点处的至少两条其他线路。连接到另一条线（或连接到自己）的线被称为具有伪节点。此规则适用于线要素必须形成闭环的情况，例如，当它们定义面的边界时，或者当线要素在逻辑上必须连接到两端的另外两个线要素时，就像流网络中的线段一样，但一阶流的起始端会标记例外情况。</para>
            /// </summary>
            [Description("Must Not Have Pseudo-Nodes (Line)")]
            [GPEnumValue("Must Not Have Pseudo-Nodes (Line)")]
            value12,

            /// <summary>
            /// <para>Must Be Covered By Feature Class Of (Line-Line)</para>
            /// <para>Must Be Covered By Feature Class Of (Line-Line)— Requires that lines from one feature class (or subtype) must be covered by the lines in another feature class (or subtype). This is useful for modeling logically different but spatially coincident lines, such as routes and streets. A bus route feature class must not depart from the streets defined in the street feature class.</para>
            /// <para>必须被要素类覆盖 （线-线）- 要求一个要素类（或子类型）中的线必须被另一个要素类（或子类型）中的线覆盖。这对于对逻辑上不同但空间上重合的线（例如路线和街道）进行建模非常有用。公交路径要素类不得偏离街道要素类中定义的街道。</para>
            /// </summary>
            [Description("Must Be Covered By Feature Class Of (Line-Line)")]
            [GPEnumValue("Must Be Covered By Feature Class Of (Line-Line)")]
            value13,

            /// <summary>
            /// <para>Must Not Overlap With (Line-Line)</para>
            /// <para>Must Not Overlap With (Line-Line)— Requires that a line from one feature class (or subtype) not overlap with line features in another feature class (or subtype). This rule is used when line features cannot share the same space. For example, roads must not overlap with railroads or depression subtypes of contour lines cannot overlap with other contour lines.</para>
            /// <para>不得与 （Line-Line） 重叠 - 要求一个要素类（或子类型）中的线不得与另一个要素类（或子类型）中的线要素重叠。当线要素不能共享同一空间时，将使用此规则。例如，道路不得与铁路重叠，或者等高线的凹陷子类型不能与其他等高线重叠。</para>
            /// </summary>
            [Description("Must Not Overlap With (Line-Line)")]
            [GPEnumValue("Must Not Overlap With (Line-Line)")]
            value14,

            /// <summary>
            /// <para>Must Be Covered By (Point-Line)</para>
            /// <para>Must Be Covered By (Point-Line)— Requires that points in one feature class be covered by lines in another feature class. It does not constrain the covering portion of the line to be an endpoint. This rule is useful for points that fall along a set of lines, such as highway signs along highways.</para>
            /// <para>必须被（点-线）覆盖 - 要求一个要素类中的点被另一个要素类中的线覆盖。它不会将线的覆盖部分限制为端点。此规则对于沿一组线落下的点（例如高速公路沿线的高速公路标志）非常有用。</para>
            /// </summary>
            [Description("Must Be Covered By (Point-Line)")]
            [GPEnumValue("Must Be Covered By (Point-Line)")]
            value15,

            /// <summary>
            /// <para>Must Be Covered By Endpoint Of (Point-Line)</para>
            /// <para>Must Be Covered By Endpoint Of (Point-Line)— Requires that points in one feature class must be covered by the endpoints of lines in another feature class. This rule is similar to the line rule Endpoint Must Be Covered By except that, in cases where the rule is violated, it is the point feature that is marked as an error rather than the line. Boundary corner markers might be constrained to be covered by the endpoints of boundary lines.</para>
            /// <para>必须被 （点-线） 的端点覆盖 - 要求一个要素类中的点必须被另一个要素类中的线的端点覆盖。此规则类似于线规则“端点必须被覆盖”，不同之处在于，在违反规则的情况下，标记为错误的是点要素，而不是线。边界角标记可能被限制为边界线的端点所覆盖。</para>
            /// </summary>
            [Description("Must Be Covered By Endpoint Of (Point-Line)")]
            [GPEnumValue("Must Be Covered By Endpoint Of (Point-Line)")]
            value16,

            /// <summary>
            /// <para>Boundary Must Be Covered By (Area-Line)</para>
            /// <para>Boundary Must Be Covered By (Area-Line)— Requires that boundaries of polygon features must be covered by lines in another feature class. This rule is used when area features need to have line features that mark the boundaries of the areas. This is usually when the areas have one set of attributes and their boundaries have other attributes. For example, parcels might be stored in the geodatabase along with their boundaries. Each parcel might be defined by one or more line features that store information about their length or the date surveyed, and every parcel should exactly match its boundaries.</para>
            /// <para>边界必须由（面积线）覆盖 - 要求面要素的边界必须由其他要素类中的线覆盖。当区域要素需要具有标记区域边界的线要素时，将使用此规则。这通常是当区域具有一组属性而其边界具有其他属性时。例如，宗地可能与其边界一起存储在地理数据库中。每个宗地可以由一个或多个线要素定义，这些线要素存储有关其长度或测量日期的信息，并且每个宗地都应完全匹配其边界。</para>
            /// </summary>
            [Description("Boundary Must Be Covered By (Area-Line)")]
            [GPEnumValue("Boundary Must Be Covered By (Area-Line)")]
            value17,

            /// <summary>
            /// <para>Boundary Must Be Covered By Boundary Of (Area-Area)</para>
            /// <para>Boundary Must Be Covered By Boundary Of (Area-Area)— Requires that boundaries of polygon features in one feature class (or subtype) be covered by boundaries of polygon features in another feature class (or subtype). This is useful when polygon features in one feature class, such as subdivisions, are composed of multiple polygons in another class, such as parcels, and the shared boundaries must be aligned.</para>
            /// <para>边界必须由边界覆盖 （Area-Area）- 要求一个要素类（或子类型）中的面要素的边界被另一个要素类（或子类型）中的面要素边界覆盖。当一个要素类（例如细分）中的面要素由另一个类（例如宗地）中的多个面组成，并且必须对齐共享边界时，这将非常有用。</para>
            /// </summary>
            [Description("Boundary Must Be Covered By Boundary Of (Area-Area)")]
            [GPEnumValue("Boundary Must Be Covered By Boundary Of (Area-Area)")]
            value18,

            /// <summary>
            /// <para>Must Not Self-Overlap (Line)</para>
            /// <para>Must Not Self-Overlap (Line)— Requires that line features not overlap themselves. They can cross or touch themselves but must not have coincident segments. This rule is useful for features, such as streets, where segments might touch in a loop but where the same street should not follow the same course twice.</para>
            /// <para>不得自重叠（线）- 要求线要素本身不重叠。它们可以交叉或接触自己，但不能有重合的片段。此规则对于要素（例如街道）非常有用，在这些要素中，线段可能会在环路中接触，但同一条街道不应两次遵循相同的路线。</para>
            /// </summary>
            [Description("Must Not Self-Overlap (Line)")]
            [GPEnumValue("Must Not Self-Overlap (Line)")]
            value19,

            /// <summary>
            /// <para>Must Not Self-Intersect (Line)</para>
            /// <para>Must Not Self-Intersect (Line)— Requires that line features not cross or overlap themselves. This rule is useful for lines, such as contour lines, that cannot cross themselves.</para>
            /// <para>不得自相交（线）- 要求线要素不能相互交叉或重叠。此规则对于不能自相交的线（如等高线）非常有用。</para>
            /// </summary>
            [Description("Must Not Self-Intersect (Line)")]
            [GPEnumValue("Must Not Self-Intersect (Line)")]
            value20,

            /// <summary>
            /// <para>Must Not Intersect Or Touch Interior (Line)</para>
            /// <para>Must Not Intersect Or Touch Interior (Line)— Requires that a line in one feature class (or subtype) must only touch other lines of the same feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines must only be connected at endpoints, such as in the case of lot lines, which must split (only connect to the endpoints of) back lot lines and cannot overlap each other.</para>
            /// <para>不得与内部（线）相交或接触 - 要求一个要素类（或子类型）中的线只能在端点处接触同一要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当线只能在端点处连接时，此规则很有用，例如在批次线的情况下，批次线必须拆分（仅连接到）后批线的端点，并且不能相互重叠。</para>
            /// </summary>
            [Description("Must Not Intersect Or Touch Interior (Line)")]
            [GPEnumValue("Must Not Intersect Or Touch Interior (Line)")]
            value21,

            /// <summary>
            /// <para>Endpoint Must Be Covered By (Line-Point)</para>
            /// <para>Endpoint Must Be Covered By (Line-Point)— Requires that the endpoints of line features must be covered by point features in another feature class. This is useful for modeling cases where a fitting must connect two pipes or a street intersection must be found at the junction of two streets.</para>
            /// <para>端点必须被 （线点）覆盖 - 要求线要素的端点必须被其他要素类中的点要素覆盖。这对于以下情况非常有用：管接头必须连接两条管道，或者必须在两条街道的交汇处找到街道交叉口。</para>
            /// </summary>
            [Description("Endpoint Must Be Covered By (Line-Point)")]
            [GPEnumValue("Endpoint Must Be Covered By (Line-Point)")]
            value22,

            /// <summary>
            /// <para>Contains Point (Area-Point)</para>
            /// <para>Contains Point (Area-Point)— Requires that a polygon in one feature class contain at least one point from another feature class. Points must be within the polygon, not on the boundary. This is useful when every polygon should have at least one associated point, such as when parcels must have an address point.</para>
            /// <para>包含点 （Area-Point） - 要求一个要素类中的面至少包含另一个要素类中的一个点。点必须位于面内，而不是边界上。当每个面都应至少有一个关联点时，例如宗地必须具有地址点时，这很有用。</para>
            /// </summary>
            [Description("Contains Point (Area-Point)")]
            [GPEnumValue("Contains Point (Area-Point)")]
            value23,

            /// <summary>
            /// <para>Must Be Single Part (Line)</para>
            /// <para>Must Be Single Part (Line)— Requires that lines have only one part. This rule is useful where line features, such as highways, may not have multiple parts.</para>
            /// <para>必须是单个零件（线）- 要求线只有一个零件。当线要素（例如高速公路）可能没有多个部分时，此规则非常有用。</para>
            /// </summary>
            [Description("Must Be Single Part (Line)")]
            [GPEnumValue("Must Be Single Part (Line)")]
            value24,

            /// <summary>
            /// <para>Must Coincide With (Point-Point)</para>
            /// <para>Must Coincide With (Point-Point)— Requires that points in one feature class (or subtype) be coincident with points in another feature class (or subtype). This is useful for cases where points must be covered by other points, such as transformers must coincide with power poles in electric distribution networks and observation points must coincide with stations.</para>
            /// <para>必须与 （Point-Point） 重合 - 要求一个要素类（或子类型）中的点与另一个要素类（或子类型）中的点重合。这对于点必须被其他点覆盖的情况很有用，例如变压器必须与配电网中的电线杆重合，观测点必须与站点重合。</para>
            /// </summary>
            [Description("Must Coincide With (Point-Point)")]
            [GPEnumValue("Must Coincide With (Point-Point)")]
            value25,

            /// <summary>
            /// <para>Must Be Disjoint (Point)</para>
            /// <para>Must Be Disjoint (Point)— Requires that points be separated spatially from other points in the same feature class (or subtype). Any points that overlap are errors. This is useful for ensuring that points are not coincident or duplicated within the same feature class, such as in layers of cities, parcel lot ID points, wells, or streetlamp poles.</para>
            /// <para>必须不相交（点）- 要求点在空间上与同一要素类（或子类型）中的其他点分开。任何重叠的点都是错误。这对于确保点在同一要素类中不重合或重复非常有用，例如在城市图层、宗地批 ID 点、井或路灯杆中。</para>
            /// </summary>
            [Description("Must Be Disjoint (Point)")]
            [GPEnumValue("Must Be Disjoint (Point)")]
            value26,

            /// <summary>
            /// <para>Must Not Intersect With (Line-Line)</para>
            /// <para>Must Not Intersect With (Line-Line)— Requires that line features from one feature class (or subtype) not cross or overlap lines from another feature class (or subtype). Lines can share endpoints. This rule is used when there are lines from two layers that should never cross each other or in cases where the intersection of lines should only occur at endpoints, such as streets and railroads.</para>
            /// <para>不得与 （Line-Line） 相交 - 要求一个要素类（或子类型）的线要素不得与另一个要素类（或子类型）的线相交或重叠。线路可以共享端点。当两个图层中的线不应相互交叉时，或者线的交点应仅发生在端点（例如街道和铁路）处时，将使用此规则。</para>
            /// </summary>
            [Description("Must Not Intersect With (Line-Line)")]
            [GPEnumValue("Must Not Intersect With (Line-Line)")]
            value27,

            /// <summary>
            /// <para>Must Not Intersect or Touch Interior With (Line-Line)</para>
            /// <para>Must Not Intersect or Touch Interior With (Line-Line)— Requires that a line in one feature class (or subtype) must only touch other lines of another feature class (or subtype) at endpoints. Any line segment in which features overlap or any intersection not at an endpoint is an error. This rule is useful where lines from two layers must only be connected at endpoints.</para>
            /// <para>不得与内部相交或接触 （线-线） - 要求一个要素类（或子类型）中的线只能在端点处接触另一个要素类（或子类型）的其他线。要素重叠的任何线段或不在端点处的任何交点都是错误。当两个图层的线路只能在端点处连接时，此规则非常有用。</para>
            /// </summary>
            [Description("Must Not Intersect or Touch Interior With (Line-Line)")]
            [GPEnumValue("Must Not Intersect or Touch Interior With (Line-Line)")]
            value28,

            /// <summary>
            /// <para>Must Be Inside (Line-Area)</para>
            /// <para>Must Be Inside (Line-Area)— Requires that a line is contained within the boundary of an area feature. This is useful for cases where lines may partially or totally coincide with area boundaries but cannot extend beyond polygons, such as state highways that must be inside state borders and rivers that must be within watersheds.</para>
            /// <para>必须位于内部（线-区域）- 要求线包含在区域要素的边界内。这对于线可能部分或完全重合区域边界但不能延伸到多边形之外的情况非常有用，例如必须在州边界内的州高速公路和必须在流域内的河流。</para>
            /// </summary>
            [Description("Must Be Inside (Line-Area)")]
            [GPEnumValue("Must Be Inside (Line-Area)")]
            value29,

            /// <summary>
            /// <para>Contains One Point (Area-Point)</para>
            /// <para>Contains One Point (Area-Point)— Requires that each polygon contains one point feature and that each point feature falls within a single polygon. This is used when there must be a one-to-one correspondence between features of a polygon feature class and features of a point feature class, such as administrative boundaries and their capital cities. Each point must be properly inside exactly one polygon and each polygon must properly contain exactly one point. Points must be within the polygon, not on the boundary.</para>
            /// <para>包含一个点 （Area-Point） - 要求每个面包含一个点要素，并且每个点要素都位于单个面内。当面要素类的要素与点要素类的要素（例如行政边界及其首府城市）之间必须存在一对一对应关系时，会使用此选项。每个点必须正好位于一个多边形内，并且每个多边形必须正确地包含一个点。点必须位于面内，而不是边界上。</para>
            /// </summary>
            [Description("Contains One Point (Area-Point)")]
            [GPEnumValue("Contains One Point (Area-Point)")]
            value30,

        }

        /// <summary>
        /// <para>Input Feature class</para>
        /// <para>The input or origin feature class.</para>
        /// <para>输入要素类或原点要素类。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Feature class")]
        [Description("")]
        [Option(OptionTypeEnum.Must)]
        public object _in_featureclass { get; set; }


        /// <summary>
        /// <para>Input Subtype</para>
        /// <para>The subtype for the input or origin feature class. Enter the subtype's description (not the code). If subtypes do not exist on the origin feature class, or you want the rule to be applied to all subtypes in the feature class, leave this blank.</para>
        /// <para>输入要素类或源要素类的子类型。输入子类型的描述（而不是代码）。如果源要素类上不存在子类型，或者您希望将规则应用于要素类中的所有子类型，请将其留空。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Subtype")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public object _subtype { get; set; } = null;


        /// <summary>
        /// <para>Input Feature class</para>
        /// <para>The destination feature class for the topology rule.</para>
        /// <para>拓扑规则的目标要素类。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Feature class")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public object _in_featureclass2 { get; set; } = null;


        /// <summary>
        /// <para>Input Subtype</para>
        /// <para>The subtype for the destination feature class. Enter the subtype's description (not the code). If subtypes do not exist on the origin feature class, or you want the rule to be applied to all subtypes in the feature class, leave this blank.</para>
        /// <para>目标要素类的子类型。输入子类型的描述（而不是代码）。如果源要素类上不存在子类型，或者您希望将规则应用于要素类中的所有子类型，请将其留空。</para>
        /// <para></para>
        /// </summary>
        [DisplayName("Input Subtype")]
        [Description("")]
        [Option(OptionTypeEnum.optional)]
        public object _subtype2 { get; set; } = null;


        /// <summary>
        /// <para>Updated Input Topology</para>
        /// <para></para>
        /// <para></para>
        /// <para></para>
        /// </summary>
        [DisplayName("Updated Input Topology")]
        [Description("")]
        [Option(OptionTypeEnum.derived)]
        public object _out_topology { get; set; }


        public AddRuleToTopology SetEnv(object workspace = null)
        {
            base.SetEnv(workspace: workspace);
            return this;
        }

    }

}